import { dbService } from './dbService';
import configService from './configService';

// 定时任务类型枚举
export const TASK_TYPES = {
  MASS_MESSAGE: 'mass_message',  // 群发消息
  TIMELINE_POST: 'timeline_post', // 朋友圈发布
  // 可以在此添加更多任务类型
};

// 任务状态枚举
export const TASK_STATUS = {
  PENDING: 'pending',    // 等待执行
  COMPLETED: 'completed', // 已完成
  CANCELLED: 'cancelled', // 已取消
  FAILED: 'failed'       // 执行失败
};

class SchedulerService {
  constructor() {
    this.tasks = [];
    this.isInitialized = false;
    this.checkInterval = 60000; // 默认每分钟检查一次
    this.timerId = null;
    this.handlers = {}; // 存储不同类型任务的处理函数
    this.enabled = false; // 定时器是否启用
    
    // 绑定方法
    this.initialize = this.initialize.bind(this);
    this.checkTasks = this.checkTasks.bind(this);
    this.addTask = this.addTask.bind(this);
    this.cancelTask = this.cancelTask.bind(this);
    this.registerTaskHandler = this.registerTaskHandler.bind(this);
    this.setEnabled = this.setEnabled.bind(this);
  }

  // 初始化服务
  async initialize() {
    if (this.isInitialized) return;
    
    try {
      // 初始化配置服务
      await configService.initialize();
      
      // 从配置中获取定时器启用状态
      const schedulerConfig = configService.getConfig('scheduler');
      this.enabled = schedulerConfig?.enabled || false;
      
      // 从IndexedDB加载任务数据
      const tasksData = await dbService.get(dbService.getStoreNames().SCHEDULEDTASKS, 'scheduledTasks');
      if (tasksData && tasksData.data) {
        this.tasks = tasksData.data;
        console.log('从IndexedDB加载定时任务数据成功，共加载', this.tasks.length, '个任务');
      } else {
        this.tasks = [];
        console.log('未找到定时任务数据或数据为空');
      }
      
      // 如果定时器启用，则启动定时检查
      if (this.enabled) {
        this.startChecking();
        console.log('定时器已启用，开始定时检查');
      } else {
        console.log('定时器未启用，跳过定时检查');
      }
      
      this.isInitialized = true;
    } catch (error) {
      console.error('初始化定时任务服务失败:', error);
    }
  }

  // 开始定时检查任务
  startChecking() {
    // 如果定时器未启用，则不启动
    if (!this.enabled) {
      console.log('定时器未启用，不启动定时检查');
      return;
    }
    
    // 先清除可能存在的定时器
    if (this.timerId) {
      clearInterval(this.timerId);
    }
    
    // 立即执行一次检查
    this.checkTasks();
    
    // 设置定时检查
    this.timerId = setInterval(this.checkTasks, this.checkInterval);
    console.log(`定时任务检查服务已启动，每${this.checkInterval / 1000}秒检查一次`);
  }

  // 停止定时检查
  stopChecking() {
    if (this.timerId) {
      clearInterval(this.timerId);
      this.timerId = null;
      console.log('定时任务检查服务已停止');
    }
  }

  // 检查并执行到期任务
  async checkTasks() {
    const now = new Date();
    let tasksUpdated = false;
    
    // 遍历所有任务
    const updatedTasks = this.tasks.map(task => {
      // 只处理状态为pending的任务
      if (task.status === TASK_STATUS.PENDING) {
        // 检查任务的预定时间是否已到
        if (new Date(task.scheduledTime) <= now) {
          console.log(`执行定时任务: ${task.id}, 类型: ${task.type}`);
          
          // 根据任务类型调用相应的处理函数
          if (this.handlers[task.type]) {
            try {
              this.handlers[task.type](task);
              // 更新任务状态为已完成
              tasksUpdated = true;
              return { ...task, status: TASK_STATUS.COMPLETED, executedAt: new Date() };
            } catch (error) {
              console.error(`执行任务失败: ${task.id}`, error);
              tasksUpdated = true;
              return { ...task, status: TASK_STATUS.FAILED, error: error.message };
            }
          } else {
            console.error(`未找到任务类型的处理函数: ${task.type}`);
            tasksUpdated = true;
            return { ...task, status: TASK_STATUS.FAILED, error: `未找到任务类型的处理函数: ${task.type}` };
          }
        }
      }
      return task;
    });
    
    // 如果有任务被更新，则更新状态并保存
    if (tasksUpdated) {
      this.tasks = updatedTasks;
      await this.saveTasks();
    }
  }

  // 添加新任务
  async addTask(task) {
    if (!task.id) {
      task.id = Date.now(); // 使用时间戳作为唯一ID
    }
    
    if (!task.createdAt) {
      task.createdAt = new Date();
    }
    
    if (!task.status) {
      task.status = TASK_STATUS.PENDING;
    }
    
    // 验证必要字段
    if (!task.type || !task.scheduledTime) {
      throw new Error('任务缺少必要字段: type, scheduledTime');
    }
    
    // 添加到任务列表
    this.tasks.push(task);
    
    // 保存到存储
    await this.saveTasks();
    
    return task.id;
  }

  // 取消任务
  async cancelTask(taskId) {
    const taskIndex = this.tasks.findIndex(t => t.id === taskId);
    
    if (taskIndex === -1) {
      throw new Error(`未找到ID为${taskId}的任务`);
    }
    
    // 更新任务状态
    this.tasks[taskIndex] = {
      ...this.tasks[taskIndex],
      status: TASK_STATUS.CANCELLED,
      cancelledAt: new Date()
    };
    
    // 保存到存储
    await this.saveTasks();
    
    return true;
  }

  // 获取所有任务
  getAllTasks() {
    return [...this.tasks];
  }

  // 获取特定类型的任务
  getTasksByType(type) {
    return this.tasks.filter(task => task.type === type);
  }

  // 获取特定状态的任务
  getTasksByStatus(status) {
    return this.tasks.filter(task => task.status === status);
  }

  // 清理已完成和已取消的任务
  async cleanupTasks() {
    const activeTasks = this.tasks.filter(
      task => task.status !== TASK_STATUS.COMPLETED && task.status !== TASK_STATUS.CANCELLED
    );
    
    if (activeTasks.length !== this.tasks.length) {
      this.tasks = activeTasks;
      await this.saveTasks();
    }
    
    return this.tasks.length;
  }

  // 注册任务处理函数
  registerTaskHandler(taskType, handlerFunction) {
    if (typeof handlerFunction !== 'function') {
      throw new Error('处理函数必须是一个函数');
    }
    
    this.handlers[taskType] = handlerFunction;
    console.log(`已注册任务类型 ${taskType} 的处理函数`);
  }

  // 保存任务到IndexedDB
  async saveTasks() {
    try {
      await dbService.set(dbService.getStoreNames().SCHEDULEDTASKS, {
        id: 'scheduledTasks',
        data: this.tasks
      });
      console.log('定时任务数据已保存到IndexedDB，共', this.tasks.length, '个任务');
    } catch (error) {
      console.error('保存定时任务数据失败:', error);
      throw error;
    }
  }
  
  // 设置定时器启用状态
  async setEnabled(enabled) {
    if (this.enabled === enabled) return; // 状态未变，不处理
    
    this.enabled = enabled;
    
    // 更新配置
    await configService.setConfig('scheduler.enabled', enabled);
    
    if (enabled) {
      // 启用定时器
      this.startChecking();
      console.log('定时器已启用');
    } else {
      // 禁用定时器
      this.stopChecking();
      console.log('定时器已禁用');
    }
    
    return true;
  }
  
  // 获取定时器启用状态
  isEnabled() {
    return this.enabled;
  }
  
  // 获取定时器配置缓存状态
  async getCacheSettings() {
    await configService.initialize();
    return configService.getConfig('scheduler.cacheSettings');
  }
  
  // 设置定时器配置缓存状态
  async setCacheSettings(cacheSettings) {
    await configService.setConfig('scheduler.cacheSettings', cacheSettings);
    return true;
  }
}

// 创建单例实例
const schedulerService = new SchedulerService();

// 导出服务实例
export default schedulerService;